/*
 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
 *
 * This software is open source.
 * See the bottom of this file for the licence.
 */

package org.dom4j.jaxb;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.nio.charset.Charset;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.ElementPath;
import org.dom4j.io.SAXReader;

import org.xml.sax.InputSource;

/**
 * Reads an XML document and creates a DOM4J tree from SAX parsing events.
 * {@link JAXBObjectHandler}objects can be registered to automatically receive
 * unmarshalled XML fragments. Registered {@linkorg.dom4j.ElementHandler}
 * implementations are notified when a certain element path is encountered
 * 
 * @author Wonne Keysers (Realsoftware.be)
 * 
 * @see org.dom4j.io.SAXReader
 * @see javax.xml.bind.JAXBContext
 */
public class JAXBReader extends JAXBSupport
{
   private SAXReader reader;

   private boolean pruneElements;

   /**
    * Creates a new JAXBReader for the given JAXB context path. This is the Java
    * package where JAXB can find the generated XML classes. This package MUST
    * contain jaxb.properties!
    * 
    * @param contextPath context path to be used
    * 
    * @see javax.xml.bind.JAXBContext
    */
   public JAXBReader(String contextPath)
   {
      super(contextPath);
   }

   /**
    * Creates a new JAXBReader for the given JAXB context path, using the
    * specified {@link java.lang.Classloader}. This is the Java package where
    * JAXB can find the generated XML classes. This package MUST contain
    * jaxb.properties!
    * 
    * @param contextPath to be used
    * @param classloader to be used
    * 
    * @see javax.xml.bind.JAXBContext
    */
   public JAXBReader(String contextPath, ClassLoader classloader)
   {
      super(contextPath, classloader);
   }

   /**
    * Parses the specified {@link java.io.File}
    * 
    * @param source the file to parse
    * 
    * @return the resulting DOM4J document
    * 
    * @throws DocumentException when an error occurs while parsing
    */
   public Document read(File source) throws DocumentException
   {
      return getReader().read(source);
   }

   /**
    * Parses the specified {@link java.io.File}, using the given {@link
    * java.nio.charset.Charset}.
    * 
    * @param file the file to parse
    * @param charset the charset to be used
    * 
    * @return the resulting DOM4J document
    * 
    * @throws DocumentException when an error occurs while parsing
    */
   public Document read(File file, Charset charset) throws DocumentException
   {
      try
      {
         Reader xmlReader =
            new InputStreamReader(new FileInputStream(file), charset);

         return getReader().read(xmlReader);
      }
      catch(JAXBRuntimeException ex)
      {
         Throwable cause = ex.getCause();
         throw new DocumentException(cause.getMessage(), cause);
      }
      catch(FileNotFoundException ex)
      {
         throw new DocumentException(ex.getMessage(), ex);
      }
   }

   /**
    * Parses the specified {@link org.xml.sax.InputSource}
    * 
    * @param source the source to parse
    * 
    * @return the resulting DOM4J document
    * 
    * @throws DocumentException when an error occurs while parsing
    */
   public Document read(InputSource source) throws DocumentException
   {
      try
      {
         return getReader().read(source);
      }
      catch(JAXBRuntimeException ex)
      {
         Throwable cause = ex.getCause();
         throw new DocumentException(cause.getMessage(), cause);
      }
   }

   /**
    * Parses the specified {@link java.io.InputStream}
    * 
    * @param source the input stream to parse
    * 
    * @return the resulting DOM4J document
    * 
    * @throws DocumentException when an error occurs while parsing
    */
   public Document read(InputStream source) throws DocumentException
   {
      try
      {
         return getReader().read(source);
      }
      catch(JAXBRuntimeException ex)
      {
         Throwable cause = ex.getCause();
         throw new DocumentException(cause.getMessage(), cause);
      }
   }

   /**
    * Parses the specified {@link java.io.InputStream}
    * 
    * @param source the input stream to parse
    * @param systemId is the URI for the input
    * 
    * @return the resulting DOM4J document
    * 
    * @throws DocumentException when an error occurs while parsing
    */
   public Document read(InputStream source, String systemId)
      throws DocumentException
   {
      try
      {
         return getReader().read(source);
      }
      catch(JAXBRuntimeException ex)
      {
         Throwable cause = ex.getCause();
         throw new DocumentException(cause.getMessage(), cause);
      }
   }

   /**
    * Parses the specified {@link java.io.Reader}
    * 
    * @param source the input reader to use
    * 
    * @return the resulting DOM4J document
    * 
    * @throws DocumentException when an error occurs while parsing
    */
   public Document read(Reader source) throws DocumentException
   {
      try
      {
         return getReader().read(source);
      }
      catch(JAXBRuntimeException ex)
      {
         Throwable cause = ex.getCause();
         throw new DocumentException(cause.getMessage(), cause);
      }
   }

   /**
    * Parses the specified {@link java.io.Reader}
    * 
    * @param source the input reader to parse
    * @param systemId is the URI for the input
    * 
    * @return the resulting DOM4J document
    * 
    * @throws DocumentException when an error occurs while parsing
    */
   public Document read(Reader source, String systemId)
      throws DocumentException
   {
      try
      {
         return getReader().read(source);
      }
      catch(JAXBRuntimeException ex)
      {
         Throwable cause = ex.getCause();
         throw new DocumentException(cause.getMessage(), cause);
      }
   }

   /**
    * Parses the the given URL or filename.
    * 
    * @param source the location to parse
    * 
    * @return the resulting DOM4J document
    * 
    * @throws DocumentException when an error occurs while parsing
    */
   public Document read(String source) throws DocumentException
   {
      try
      {
         return getReader().read(source);
      }
      catch(JAXBRuntimeException ex)
      {
         Throwable cause = ex.getCause();
         throw new DocumentException(cause.getMessage(), cause);
      }
   }

   /**
    * Parses the the given URL.
    * 
    * @param source the URL to parse
    * 
    * @return the resulting DOM4J document
    * 
    * @throws DocumentException when an error occurs while parsing
    */
   public Document read(URL source) throws DocumentException
   {
      try
      {
         return getReader().read(source);
      }
      catch(JAXBRuntimeException ex)
      {
         Throwable cause = ex.getCause();
         throw new DocumentException(cause.getMessage(), cause);
      }
   }

   /**
    * Registers a {@link JAXBObjectHandler}that will be supplied with the
    * unmarshalled representation of the xml fragment whenever the specified
    * path is encounted.
    * 
    * @param path the path to listen for
    * @param handler the handler to be notified
    */
   public void addObjectHandler(String path, JAXBObjectHandler handler)
   {
      ElementHandler eHandler = new UnmarshalElementHandler(this, handler);
      getReader().addHandler(path, eHandler);
   }

   /**
    * Removes the {@link JAXBObjectHandler}from the event based processor, for
    * the specified element path.
    * 
    * @param path The path to remove the {@link JAXBObjectHandler}for
    */
   public void removeObjectHandler(String path)
   {
      getReader().removeHandler(path);
   }

   /**
    * Adds the <code>ElementHandler</code> to be called when the specified
    * path is encounted.
    * 
    * @param path is the path to be handled
    * @param handler is the <code>ElementHandler</code> to be called by the
    *           event based processor.
    */
   public void addHandler(String path, ElementHandler handler)
   {
      getReader().addHandler(path, handler);
   }

   /**
    * Removes the <code>ElementHandler</code> from the event based processor,
    * for the specified path.
    * 
    * @param path is the path to remove the <code>ElementHandler</code> for.
    */
   public void removeHandler(String path)
   {
      getReader().removeHandler(path);
   }

   /**
    * Removes all registered {@link JAXBObjectHandler}and {@link
    * org.dom4j.ElementHandler} instances from the event based processor.
    */
   public void resetHandlers()
   {
      getReader().resetHandlers();
   }

   /**
    * When 'true', the DOM4J document will not be kept in memory while parsing.
    * 
    * @return Returns the pruneElements.
    */
   public boolean isPruneElements()
   {
      return pruneElements;
   }

   /**
    * Set to true when DOM4J elements must immediately be pruned from the tree.
    * The {@link Document}will not be available afterwards!
    * 
    * @param pruneElements
    */
   public void setPruneElements(boolean pruneElements)
   {
      this.pruneElements = pruneElements;

      if(pruneElements)
      {
         getReader().setDefaultHandler(new PruningElementHandler());
      }
   }

   private SAXReader getReader()
   {
      if(reader == null)
      {
         reader = new SAXReader();
      }

      return reader;
   }

   private class UnmarshalElementHandler implements ElementHandler
   {
      private JAXBReader jaxbReader;

      private JAXBObjectHandler handler;

      public UnmarshalElementHandler(JAXBReader documentReader,
         JAXBObjectHandler handler)
      {
         this.jaxbReader = documentReader;
         this.handler = handler;
      }

      public void onStart(ElementPath elementPath)
      {
      }

      public void onEnd(ElementPath elementPath)
      {
         try
         {
            org.dom4j.Element elem = elementPath.getCurrent();

            javax.xml.bind.Element jaxbObject =
               (javax.xml.bind.Element) jaxbReader.unmarshal(elem);

            if(jaxbReader.isPruneElements())
            {
               elem.detach();
            }

            handler.handleObject(jaxbObject);
         }
         catch(Exception ex)
         {
            throw new JAXBRuntimeException(ex);
         }
      }
   }

   private class PruningElementHandler implements ElementHandler
   {
      public PruningElementHandler()
      {
      }

      public void onStart(ElementPath parm1)
      {
      }

      public void onEnd(ElementPath elementPath)
      {
         Element elem = elementPath.getCurrent();
         elem.detach();
         elem = null;
      }
   }
}

/*
 * Redistribution and use of this software and associated documentation
 * ("Software"), with or without modification, are permitted provided that the
 * following conditions are met:
 * 
 * 1. Redistributions of source code must retain copyright statements and
 * notices. Redistributions must also contain a copy of this document.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * 
 * 3. The name "DOM4J" must not be used to endorse or promote products derived
 * from this Software without prior written permission of MetaStuff, Ltd. For
 * written permission, please contact dom4j-info@metastuff.com.
 * 
 * 4. Products derived from this Software may not be called "DOM4J" nor may
 * "DOM4J" appear in their names without prior written permission of MetaStuff,
 * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
 * 
 * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
 * 
 * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
 */
